With a few exceptions.
typedef GtkApplication DemoApplication;
typedef GtkApplicationClass DemoApplicationClass;
+static GType demo_application_get_type (void);
G_DEFINE_TYPE (DemoApplication, demo_application, GTK_TYPE_APPLICATION)
typedef struct {
} DemoApplicationWindow;
typedef GtkApplicationWindowClass DemoApplicationWindowClass;
+static GType demo_application_window_get_type (void);
G_DEFINE_TYPE (DemoApplicationWindow, demo_application_window, GTK_TYPE_APPLICATION_WINDOW)
static void create_window (GApplication *app, const char *contents);
#include <gtk/gtk.h>
-static GtkWidget *assistant = NULL;
+/*static GtkWidget *assistant = NULL;*/
static GtkWidget *progress_bar = NULL;
static gboolean
else
{
/* Close automatically once changes are fully applied. */
- gtk_widget_destroy (assistant);
- assistant = NULL;
+ gtk_widget_destroy (data);
return G_SOURCE_REMOVE;
}
}
on_assistant_apply (GtkWidget *widget, gpointer data)
{
/* Start a timer to simulate changes taking a few seconds to apply. */
- g_timeout_add (100, apply_changes_gradually, NULL);
+ g_timeout_add (100, apply_changes_gradually, widget);
}
static void
GtkWidget*
do_assistant (GtkWidget *do_widget)
{
+ static GtkWidget *assistant;
+
if (!assistant)
{
assistant = gtk_assistant_new ();
static GtkWidget *window = NULL;
-void
+static void
copy_button_clicked (GtkWidget *button,
gpointer user_data)
{
gdk_clipboard_set_text (clipboard, gtk_editable_get_text (GTK_EDITABLE (entry)));
}
-void
+static void
paste_received (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
}
}
-void
+static void
paste_button_clicked (GtkWidget *button,
gpointer user_data)
{
if (icon == NULL)
return NULL;
return GDK_PAINTABLE (icon);
+
+ case GTK_IMAGE_EMPTY:
+ case GTK_IMAGE_GICON:
default:
g_warning ("Image storage type %d not handled",
gtk_image_get_storage_type (image));
/* draw callback for the drawing area
*/
static void
-draw_function (GtkDrawingArea *da,
+draw_function (GtkDrawingArea *drawing_area,
cairo_t *cr,
int width,
int height,
static GtkTreeModel *
create_icon_store (void)
{
- const gchar *icon_names[6] = {
+ const char *icon_names[6] = {
"dialog-warning",
"process-stop",
"document-new",
NULL,
"document-open"
};
- const gchar *labels[6] = {
+ const char *labels[6] = {
N_("Warning"),
N_("Stop"),
N_("New"),
create_capital_store (void)
{
struct {
- gchar *group;
- gchar *capital;
+ const char *group;
+ const char *capital;
} capitals[] = {
{ "A - B", NULL },
{ NULL, "Albany" },
struct _MaskEntry
{
GtkEntry entry;
- gchar *mask;
+ const char *mask;
};
typedef struct _MaskEntryClass MaskEntryClass;
static void mask_entry_editable_init (GtkEditableInterface *iface);
+static GType mask_entry_get_type (void);
G_DEFINE_TYPE_WITH_CODE (MaskEntry, mask_entry, GTK_TYPE_ENTRY,
G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
mask_entry_editable_init));
* These are the available blend modes.
*/
struct {
- gchar *name;
- gchar *id;
+ const char *name;
+ const char *id;
} blend_modes[] =
{
{ "Color", "color" },
gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
}
-GtkWidget *
+static GtkWidget *
create_toolbar (void)
{
GtkWidget *toolbar;
}
#define GTK_TYPE_DEMO_WIDGET (gtk_demo_widget_get_type ())
-
+static GType gtk_demo_widget_get_type (void);
G_DEFINE_BOXED_TYPE (GtkDemoWidget, gtk_demo_widget, copy_demo_widget, free_demo_widget)
static GtkDemoWidget *
g_array_index (articles, Item, i).product, -1);
}
break;
+
+ default:
+ g_assert_not_reached ();
}
gtk_tree_path_free (path);
#include <gtk/gtk.h>
/* Creates a tree model containing the completions */
-GtkTreeModel *
+static GtkTreeModel *
create_completion_model (void)
{
GtkListStore *store;
return icon_names[g_random_int_range(0, n_icon_names)];
}
+/* Can't be static because it's also used in iconscroll.c */
GtkWidget *
create_icon (void)
{
#define MAKE_TAG(a,b,c,d) (unsigned int)(((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
-static GtkWidget *label;
+static GtkWidget *the_label;
static GtkWidget *settings;
static GtkWidget *description;
static GtkWidget *font;
static GtkWidget *script_lang;
static GtkWidget *resetbutton;
static GtkWidget *stack;
-static GtkWidget *entry;
+static GtkWidget *the_entry;
static GtkWidget *variations_heading;
static GtkWidget *variations_grid;
static GtkWidget *instance_combo;
char *font_desc;
char *features;
- text = gtk_editable_get_text (GTK_EDITABLE (entry));
+ text = gtk_editable_get_text (GTK_EDITABLE (the_entry));
- if (gtk_label_get_selection_bounds (GTK_LABEL (label), &ins, &bound))
+ if (gtk_label_get_selection_bounds (GTK_LABEL (the_label), &ins, &bound))
{
start = g_utf8_offset_to_pointer (text, ins) - text;
end = g_utf8_offset_to_pointer (text, bound) - text;
gtk_label_set_text (GTK_LABEL (description), font_desc);
gtk_label_set_text (GTK_LABEL (settings), features);
- gtk_label_set_text (GTK_LABEL (label), text);
- gtk_label_set_attributes (GTK_LABEL (label), attrs);
+ gtk_label_set_text (GTK_LABEL (the_label), text);
+ gtk_label_set_attributes (GTK_LABEL (the_label), attrs);
g_free (font_desc);
pango_font_description_free (desc);
{
const char *langname;
char langbuf[5];
- GtkTreeIter iter;
+ GtkTreeIter tree_iter;
if (pair->lang_tag == HB_OT_TAG_DEFAULT_LANGUAGE)
langname = NC_("Language", "Default");
}
}
- gtk_list_store_insert_with_values (store, &iter, -1,
+ gtk_list_store_insert_with_values (store, &tree_iter, -1,
0, langname,
1, pair->script_index,
2, pair->lang_index,
if (pair->lang_tag == active)
{
have_active = TRUE;
- active_iter = iter;
+ active_iter = tree_iter;
}
}
GHashTableIter iter;
Axis *axis;
char buf[G_ASCII_DTOSTR_BUF_SIZE];
- char *sep = "";
+ const char *sep = "";
g_hash_table_iter_init (&iter, axes);
while (g_hash_table_iter_next (&iter, (gpointer *)NULL, (gpointer *)&axis))
{
GList *l;
- gtk_label_select_region (GTK_LABEL (label), 0, 0);
+ gtk_label_select_region (GTK_LABEL (the_label), 0, 0);
g_list_free_full (ranges, free_range);
ranges = NULL;
static void
switch_to_entry (void)
{
- text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry)));
+ text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (the_entry)));
gtk_stack_set_visible_child_name (GTK_STACK (stack), "entry");
- gtk_widget_grab_focus (entry);
+ gtk_widget_grab_focus (the_entry);
}
static void
window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
feature_list = GTK_WIDGET (gtk_builder_get_object (builder, "feature_list"));
- label = GTK_WIDGET (gtk_builder_get_object (builder, "label"));
+ the_label = GTK_WIDGET (gtk_builder_get_object (builder, "label"));
settings = GTK_WIDGET (gtk_builder_get_object (builder, "settings"));
description = GTK_WIDGET (gtk_builder_get_object (builder, "description"));
resetbutton = GTK_WIDGET (gtk_builder_get_object (builder, "reset"));
font = GTK_WIDGET (gtk_builder_get_object (builder, "font"));
script_lang = GTK_WIDGET (gtk_builder_get_object (builder, "script_lang"));
stack = GTK_WIDGET (gtk_builder_get_object (builder, "stack"));
- entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry"));
+ the_entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry"));
edit_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "edit_toggle"));
controller = gtk_event_controller_key_new ();
- g_object_set_data_full (G_OBJECT (entry), "controller", g_object_ref (controller), g_object_unref);
- g_signal_connect (controller, "key-pressed", G_CALLBACK (entry_key_press), entry);
- gtk_widget_add_controller (entry, controller);
+ g_object_set_data_full (G_OBJECT (the_entry), "controller", g_object_ref (controller), g_object_unref);
+ g_signal_connect (controller, "key-pressed", G_CALLBACK (entry_key_press), the_entry);
+ gtk_widget_add_controller (the_entry, controller);
add_check_group (feature_list, _("Kerning"), (const char *[]){ "kern", NULL });
add_check_group (feature_list, _("Ligatures"), (const char *[]){ "liga",
cairo_font_options_t *fopt;
cairo_hint_style_t hintstyle;
cairo_hint_metrics_t hintmetrics;
- int i;
if (!context)
context = gtk_widget_create_pango_context (image);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_grid)))
{
+ int i;
cairo_set_source_rgba (cr, 0.2, 0, 0, 0.2);
for (i = 1; i < ink.height + 20; i++)
{
struct _Demo
{
- gchar *name;
- gchar *title;
- gchar *filename;
+ const char *name;
+ const char *title;
+ const char *filename;
GDoDemoFunc func;
Demo *children;
};
rotation_angles[Z_AXIS] = 0.0;
}
-GtkWidget *
+static GtkWidget *
create_glarea_window (GtkWidget *do_widget)
{
GtkWidget *window, *box, *button, *controls;
static void
insert_link (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gchar *text,
+ const char *text,
gint page)
{
GtkTextTag *tag;
{
const gboolean fixed;
const guint number;
- const gchar *severity;
- const gchar *description;
-}
-Bug;
+ const char *severity;
+ const char *description;
+} Bug;
enum
{
NUM_COLUMNS
};
-static Bug data[] =
+static Bug bugs[] =
{
{ FALSE, 60482, "Normal", "scrollable notebooks and hidden tabs" },
{ FALSE, 60620, "Critical", "gdk_surface_clear_area (gdksurface-win32.c) is not thread-safe" },
G_TYPE_BOOLEAN);
/* add data to the list store */
- for (i = 0; i < G_N_ELEMENTS (data); i++)
+ for (i = 0; i < G_N_ELEMENTS (bugs); i++)
{
- gchar *icon_name;
+ const char *icon_name;
gboolean sensitive;
if (i == 1 || i == 3)
sensitive = TRUE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
- COLUMN_FIXED, data[i].fixed,
- COLUMN_NUMBER, data[i].number,
- COLUMN_SEVERITY, data[i].severity,
- COLUMN_DESCRIPTION, data[i].description,
+ COLUMN_FIXED, bugs[i].fixed,
+ COLUMN_NUMBER, bugs[i].number,
+ COLUMN_SEVERITY, bugs[i].severity,
+ COLUMN_DESCRIPTION, bugs[i].description,
COLUMN_PULSE, 0,
COLUMN_ICON, icon_name,
COLUMN_ACTIVE, FALSE,
static void
fixed_toggled (GtkCellRendererToggle *cell,
- gchar *path_str,
+ char *path_str,
gpointer data)
{
- GtkTreeModel *model = (GtkTreeModel *)data;
+ GtkTreeModel *tree_model = (GtkTreeModel *)data;
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
gboolean fixed;
/* get toggled iter */
- gtk_tree_model_get_iter (model, &iter, path);
- gtk_tree_model_get (model, &iter, COLUMN_FIXED, &fixed, -1);
+ gtk_tree_model_get_iter (tree_model, &iter, path);
+ gtk_tree_model_get (tree_model, &iter, COLUMN_FIXED, &fixed, -1);
/* do something with the value */
fixed ^= 1;
/* set new value */
- gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_FIXED, fixed, -1);
+ gtk_list_store_set (GTK_LIST_STORE (tree_model), &iter, COLUMN_FIXED, fixed, -1);
/* clean up */
gtk_tree_path_free (path);
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
- GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* column for fixed toggles */
renderer = gtk_cell_renderer_toggle_new ();
STATE_IN_COMMENT
};
-static gchar *tokens[] =
+static const char *tokens[] =
{
"/*",
"\"",
NULL
};
-static gchar *types[] =
+static const char *types[] =
{
"static",
"const ",
NULL
};
-static gchar *control[] =
+static const char *control[] =
{
" if ",
" while ",
NULL
};
void
-parse_chars (gchar *text,
- gchar **end_ptr,
- gint *state,
- gchar **tag,
- gboolean start)
+parse_chars (gchar *text,
+ gchar **end_ptr,
+ gint *state,
+ const char **tag,
+ gboolean start)
{
gint i;
gchar *next_token;
gint state;
gchar *text;
gchar *start_ptr, *end_ptr;
- gchar *tag;
+ const char *tag;
gtk_text_buffer_create_tag (source_buffer, "source",
"font", "monospace",
p = lines[i];
state++;
- /* Fall through */
+ G_GNUC_FALLTHROUGH;
case 3:
/* Reading program body */
if (lines[i+1] != NULL)
gtk_text_buffer_insert (source_buffer, &start, "\n", 1);
break;
+
+ default:
+ g_assert_not_reached ();
}
}
{
GtkBuilder *builder;
GMenuModel *appmenu;
- gchar *ids[] = { "appmenu", NULL };
+ const char *ids[] = { "appmenu", NULL };
builder = gtk_builder_new ();
- gtk_builder_add_objects_from_resource (builder, "/ui/appmenu.ui", ids, NULL);
+ gtk_builder_add_objects_from_resource (builder, "/ui/appmenu.ui", (char **)ids, NULL);
appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
'demo.gresource.xml',
source_dir: '.')
+demo_cflags = []
+foreach flag: common_cflags
+ if flag not in ['-Werror=missing-prototypes', '-Werror=missing-declarations', '-fvisibility=hidden']
+ demo_cflags += flag
+ endif
+endforeach
+
executable('gtk4-demo',
demos, demos_h, extra_demo_sources, gtkdemo_resources,
- c_args: gtkdemo_args,
+ c_args: gtkdemo_args + demo_cflags,
dependencies: gtkdemo_deps,
include_directories: confinc,
gui_app: true,
executable('gtk4-demo-application',
'application.c', gtkdemo_resources,
- c_args: gtkdemo_args,
+ c_args: gtkdemo_args + common_cflags,
dependencies: gtkdemo_deps,
include_directories: confinc,
gui_app: true,
"orange"
};
+static GType drawing_area_get_type (void);
G_DEFINE_TYPE (DrawingArea, drawing_area, GTK_TYPE_WIDGET)
static void drawing_area_set_color (DrawingArea *area,
area->draw_color = (GdkRGBA) { 0, 0, 0, 1 };
}
-GtkWidget *
+static GtkWidget *
drawing_area_new (void)
{
return g_object_new (drawing_area_get_type (), NULL);
#include <gtk/gtk.h>
-void
+static void
toggle_resize (GtkWidget *widget,
GtkWidget *child)
{
g_object_unref (child);
}
-void
+static void
toggle_shrink (GtkWidget *widget,
GtkWidget *child)
{
g_object_unref (child);
}
-GtkWidget *
+static GtkWidget *
create_pane_options (GtkPaned *paned,
const gchar *frame_label,
const gchar *label1,
(double) attr->ink_rect.width / PANGO_SCALE,
(double) attr->ink_rect.height / PANGO_SCALE);
- switch (GPOINTER_TO_UINT (attr->data))
+ if (GPOINTER_TO_UINT (attr->data) == 0x2664) /* U+2665 BLACK HEART SUIT */
{
- case 0x2665: /* U+2665 BLACK HEART SUIT */
- {
- cairo_move_to (cr, .5, .0);
- cairo_line_to (cr, .9, -.4);
- cairo_curve_to (cr, 1.1, -.8, .5, -.9, .5, -.5);
- cairo_curve_to (cr, .5, -.9, -.1, -.8, .1, -.4);
- cairo_close_path (cr);
- }
- break;
+ cairo_move_to (cr, .5, .0);
+ cairo_line_to (cr, .9, -.4);
+ cairo_curve_to (cr, 1.1, -.8, .5, -.9, .5, -.5);
+ cairo_curve_to (cr, .5, -.9, -.1, -.8, .1, -.4);
+ cairo_close_path (cr);
}
- if (!do_path) {
- cairo_set_source_rgb (cr, 1., 0., 0.);
- cairo_fill (cr);
- }
+ if (!do_path)
+ {
+ cairo_set_source_rgb (cr, 1., 0., 0.);
+ cairo_fill (cr);
+ }
}
-PangoAttrList *
+static PangoAttrList *
create_fancy_attr_list_for_layout (PangoLayout *layout)
{
PangoAttrList *attrs;
/* Draw the layout N_WORDS times in a circle */
for (i = 0; i < N_WORDS; i++)
{
- int width, height;
+ int layout_width, layout_height;
/* Inform Pango to re-layout the text with the new transformation matrix */
pango_cairo_update_layout (cr, layout);
- pango_layout_get_pixel_size (layout, &width, &height);
- cairo_move_to (cr, - width / 2, - RADIUS * .9);
+ pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
+ cairo_move_to (cr, - layout_width / 2, - RADIUS * .9);
pango_cairo_show_layout (cr, layout);
/* Rotate for the next turn */
gpointer data)
{
GtkEntry *entry = GTK_ENTRY (object);
- GActionMap *actions = data;
+ GActionMap *action_map = data;
GAction *action;
gboolean has_text;
has_text = gtk_entry_get_text_length (entry) > 0;
- action = g_action_map_lookup_action (actions, "clear");
+ action = g_action_map_lookup_action (action_map, "clear");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), has_text);
}
}
static void
-start_puzzle (GdkPaintable *puzzle)
+start_puzzle (GdkPaintable *paintable)
{
GtkWidget *picture, *grid;
GtkEventController *controller;
grid = gtk_grid_new ();
gtk_widget_set_can_focus (grid, TRUE);
gtk_container_add (GTK_CONTAINER (frame), grid);
- aspect_ratio = gdk_paintable_get_intrinsic_aspect_ratio (puzzle);
+ aspect_ratio = gdk_paintable_get_intrinsic_aspect_ratio (paintable);
if (aspect_ratio == 0.0)
aspect_ratio = 1.0;
gtk_aspect_frame_set (GTK_ASPECT_FRAME (frame), 0.5, 0.5, aspect_ratio, FALSE);
if (x == pos_x && y == pos_y)
piece = NULL;
else
- piece = gtk_puzzle_piece_new (puzzle,
+ piece = gtk_puzzle_piece_new (paintable,
x, y,
width, height);
picture = gtk_picture_new_for_paintable (piece);
}
static void
-add_choice (GtkWidget *choices,
+add_choice (GtkWidget *container,
GdkPaintable *paintable)
{
GtkWidget *icon;
icon = gtk_image_new_from_paintable (paintable);
gtk_image_set_icon_size (GTK_IMAGE (icon), GTK_ICON_SIZE_LARGE);
- gtk_container_add (GTK_CONTAINER (choices), icon);
+ gtk_container_add (GTK_CONTAINER (container), icon);
}
GtkWidget *
return TRUE;
}
-static gchar *month[12] = {
+static const char *month[12] = {
"January",
"February",
"March",
fullscreen_clicked_cb (GtkWidget *button,
gpointer unused)
{
- GtkWidget *window = GTK_WIDGET (gtk_widget_get_root (button));
+ GtkWidget *widget_window = GTK_WIDGET (gtk_widget_get_root (button));
- gtk_window_fullscreen (GTK_WINDOW (window));
+ gtk_window_fullscreen (GTK_WINDOW (widget_window));
}
GtkWidget *